// 全局变量
let currentConfig = {};

// 页面加载时获取配置和设置事件监听器
document.addEventListener('DOMContentLoaded', function() {
    // 加载配置
    loadConfig();
    loadGiteeConfig();
    // loadSyncStatus(); // 暂时移除未定义的函数调用

    // 设置事件监听器 - 检查元素是否存在
    const saveConfigBtn = document.getElementById('saveConfig');
    if (saveConfigBtn) saveConfigBtn.addEventListener('click', saveConfig);
    
    const resetConfigBtn = document.getElementById('resetConfig');
    if (resetConfigBtn) resetConfigBtn.addEventListener('click', resetConfig);
    
    const exportConfigBtn = document.getElementById('exportConfig');
    if (exportConfigBtn) exportConfigBtn.addEventListener('click', exportConfig);
    
    const importConfigBtn = document.getElementById('importConfig');
    if (importConfigBtn) importConfigBtn.addEventListener('click', importConfig);
    
    const syncToGiteeBtn = document.getElementById('syncToGitee');
    if (syncToGiteeBtn) syncToGiteeBtn.addEventListener('click', function() {
        // 假设存在syncToGitee函数
        if (typeof syncToGitee === 'function') {
            syncToGitee();
        }
    });
    
    const fetchFromGiteeBtn = document.getElementById('fetchFromGitee');
    if (fetchFromGiteeBtn) fetchFromGiteeBtn.addEventListener('click', function() {
        // 假设存在fetchFromGitee函数
        if (typeof fetchFromGitee === 'function') {
            fetchFromGitee();
        }
    });
    
    const toggleAutoSyncBtn = document.getElementById('toggleAutoSync');
    if (toggleAutoSyncBtn) toggleAutoSyncBtn.addEventListener('click', function() {
        // 假设存在toggleAutoSync函数
        if (typeof toggleAutoSync === 'function') {
            toggleAutoSync();
        }
    });
    
    const fileInput = document.getElementById('fileInput');
    if (fileInput) fileInput.addEventListener('change', handleFileImport);

    // 添加测试Gitee连接的事件监听器
    const testConnectionButton = document.getElementById('testGiteeConnection');
    if (testConnectionButton) {
        testConnectionButton.addEventListener('click', testGiteeConnection);
    }

    // 添加新配置的事件监听器
    const addNewItemButton = document.getElementById('addNewItem');
    if (addNewItemButton) {
        addNewItemButton.addEventListener('click', addNewItem);
    }

    // 添加变量按钮点击事件监听器
    setupVariableButtons();

    // 页面加载时自动从Gitee获取数据
    setTimeout(() => {
        if (typeof fetchFromGitee === 'function') {
            fetchFromGitee();
        }
    }, 1000); // 延迟1秒执行，确保页面元素加载完成
});

// 设置变量按钮的点击事件处理
function setupVariableButtons() {
    // 获取所有变量按钮
    const variableButtons = document.querySelectorAll('.variable-btn');
    
    // 为每个按钮添加点击事件
    variableButtons.forEach(button => {
        button.addEventListener('click', function() {
            // 获取按钮对应的变量值
            const variable = this.getAttribute('data-variable');
            // 获取模板输入框
            const templateInput = document.getElementById('newTemplate');
            
            // 插入变量到输入框的当前光标位置
            insertTextAtCursor(templateInput, variable);
            
            // 确保输入框获得焦点
            templateInput.focus();
        });
    });
}

// 在输入框的当前光标位置插入文本
function insertTextAtCursor(inputElement, text) {
    // 获取当前光标位置
    const startPos = inputElement.selectionStart;
    const endPos = inputElement.selectionEnd;
    const scrollTop = inputElement.scrollTop;
    
    // 插入文本
    inputElement.value = inputElement.value.substring(0, startPos) + text + inputElement.value.substring(endPos);
    
    // 设置新的光标位置（在插入的文本后面）
    inputElement.focus();
    inputElement.selectionStart = inputElement.selectionEnd = startPos + text.length;
    inputElement.scrollTop = scrollTop;
}

// 从Chrome存储加载配置
function loadConfig() {
    // 如果不在Chrome扩展环境中，使用默认配置
    if (typeof chrome === 'undefined' || !chrome.storage) {
        showStatus('当前不在Chrome扩展环境中，显示默认配置', 'error');
        loadDefaultConfig();
        return;
    }

    // 发送消息给background脚本获取配置
    chrome.runtime.sendMessage({action: 'getHotelConfig'}, function (response) {
        if (response && response.config) {
            currentConfig = response.config;
            renderConfig();
        } else {
            loadDefaultConfig();
        }
    });
}

// 加载Gitee配置
async function loadGiteeConfig() {
    try {
        const giteeConfig = await getGiteeConfig();
        if (giteeConfig) {
            document.getElementById('giteeOwner').value = giteeConfig.owner || '';
            document.getElementById('giteeRepo').value = giteeConfig.repo || '';
            document.getElementById('giteePath').value = giteeConfig.path || '';
            document.getElementById('giteeBranch').value = giteeConfig.branch || '';
            document.getElementById('giteeToken').value = giteeConfig.token || '';
        }
    } catch (error) {
        console.error('加载Gitee配置失败:', error);
    }
}

// 获取Gitee配置
async function getGiteeConfig() {
    try {
        // 先尝试从存储中获取用户保存的配置
        if (typeof chrome !== 'undefined' && chrome.storage) {
            return new Promise((resolve, reject) => {
                chrome.storage.local.get(['giteeConfig'], function(result) {
                    if (result.giteeConfig) {
                        resolve(result.giteeConfig);
                    } else {
                        // 如果没有保存的配置，尝试从gitee-config.js获取默认配置
                        fetchGiteeConfigFromFile().then(resolve).catch(reject);
                    }
                });
            });
        }
        // 如果不在Chrome扩展环境中，尝试从文件获取
        return await fetchGiteeConfigFromFile();
    } catch (error) {
        console.error('获取Gitee配置失败:', error);
        return null;
    }
}

// 从gitee-config.js文件获取配置
async function fetchGiteeConfigFromFile() {
    try {
        const response = await fetch('gitee-config.js');
        const content = await response.text();

        // 尝试匹配GITEE_CONFIG常量
        const match = content.match(/const\s+GITEE_CONFIG\s*=\s*({[\s\S]*?});/);

        if (match && match[1]) {
            try {
                // 尝试直接解析JSON
                return JSON.parse(match[1]);
            } catch (e) {
                // 如果解析失败，尝试移除注释后再解析
                let cleanedContent = match[1];
                // 移除单行注释
                cleanedContent = cleanedContent.replace(/\/\/.*$/gm, '');
                // 移除多行注释
                cleanedContent = cleanedContent.replace(/\/\*[\s\S]*?\*\//g, '');
                // 移除多余的空白
                cleanedContent = cleanedContent.trim();
                return JSON.parse(cleanedContent);
            }
        }
        return null;
    } catch (error) {
        console.error('从文件获取Gitee配置失败:', error);
        return null;
    }
}

// 保存Gitee配置
async function saveGiteeConfig(config) {
    try {
        if (typeof chrome !== 'undefined' && chrome.storage) {
            return new Promise((resolve, reject) => {
                chrome.storage.local.set({giteeConfig: config}, function() {
                    if (chrome.runtime.lastError) {
                        reject(chrome.runtime.lastError);
                    } else {
                        resolve();
                    }
                });
            });
        }
        // 如果不在Chrome扩展环境中，无法保存
        console.warn('无法保存Gitee配置：不在Chrome扩展环境中');
    } catch (error) {
        console.error('保存Gitee配置失败:', error);
        throw error;
    }
}

// 其他函数（根据需要添加）
function loadDefaultConfig() {
    // 默认配置实现 - 包含基本的酒店配置项
    currentConfig = {
        // 基础配置
        basic: {
            name: '示例酒店',
            description: '这是一个默认配置示例',
            version: '1.0.0',
            enabled: true
        },
        // 高级设置
        advanced: {
            autoRefresh: false,
            refreshInterval: 60,
            debugMode: false
        },
        // 界面设置
        ui: {
            theme: 'light',
            language: 'zh-CN',
            compactView: false
        }
    };
    renderConfig();
}

function renderConfig() {
    try {
        // 确保currentConfig存在
        if (!currentConfig || typeof currentConfig !== 'object') {
            showStatus('配置为空或无效', 'error');
            return;
        }

        // 1. 渲染基本配置字段
        // 根据配置字段更新页面元素
        const configFields = [
            'apiKey', 'endpointUrl', 'timeout', 'retryCount',
            'enableNotifications', 'theme', 'debugMode'
        ];

        configFields.forEach(field => {
            const element = document.getElementById(field);
            if (element) {
                // 处理不同类型的输入元素
                if (element.type === 'checkbox') {
                    element.checked = !!currentConfig[field];
                } else if (element.type === 'number') {
                    element.value = currentConfig[field] !== undefined ? currentConfig[field] : '';
                } else {
                    element.value = currentConfig[field] || '';
                }
            }
        });

        // 2. 处理嵌套配置项
        // 处理advancedSettings嵌套配置
        if (currentConfig.advancedSettings) {
            Object.keys(currentConfig.advancedSettings).forEach(key => {
                const element = document.getElementById(`advanced_${key}`);
                if (element) {
                    element.value = currentConfig.advancedSettings[key] || '';
                }
            });
        }

        // 3. 处理basic配置（来自loadDefaultConfig中的结构）
        if (currentConfig.basic) {
            Object.keys(currentConfig.basic).forEach(key => {
                const element = document.getElementById(`basic_${key}`);
                if (element) {
                    if (element.type === 'checkbox') {
                        element.checked = !!currentConfig.basic[key];
                    } else {
                        element.value = currentConfig.basic[key] || '';
                    }
                }
            });
        }

        // 4. 处理ui配置（来自loadDefaultConfig中的结构）
        if (currentConfig.ui) {
            Object.keys(currentConfig.ui).forEach(key => {
                const element = document.getElementById(`ui_${key}`);
                if (element) {
                    if (element.type === 'checkbox') {
                        element.checked = !!currentConfig.ui[key];
                    } else {
                        element.value = currentConfig.ui[key] || '';
                    }
                }
            });
        }

        // 5. 关键部分：渲染酒店列表数据
        // 检查是否有酒店数据（可能在不同位置，尝试多种可能的结构）
        let  hotelsDataObj = currentConfig;

        // 如果找到酒店数据，进行渲染
        if (hotelsDataObj) {
            const hotelsData =Object.keys(hotelsDataObj);
            const hotelsContainer = document.getElementById('configSection')

            if (hotelsContainer) {
                // 清空容器
                hotelsContainer.innerHTML = '';

                if (hotelsData.length === 0) {
                    hotelsContainer.innerHTML = '<p class="no-hotels">没有找到酒店数据</p>';
                } else {
                    // 为每个酒店创建UI元素
                    hotelsData.forEach((hotel, index) => {
                        const hotelElement = document.createElement('div');
                        hotelElement.className = 'hotel-item';
                        hotelElement.dataset.index = index;

                        // 创建酒店基本信息
                        const hotelName = hotel
                        const hotelInfo = hotelsDataObj[hotelName]

                        if(index%2 == 0){
                            hotelElement.innerHTML = `
                            <div class="hotel-header" style="padding-bottom: 15px">
                                <div style="display: inline-block;width:50px">${index+1}</div>
                                <div style="display: inline-block;width: 300px" >${hotelName}</div>
                                <div class="hotel-description" style="display: inline-block">${hotelInfo}</div>
                            </div>
                        `;
                        }else{
                            hotelElement.innerHTML = `
                            <div class="hotel-header" style="background-color: cyan;" >
                                <div style="display: inline-block;width:50px">${index+1}</div>
                                <div style="display: inline-block;width: 300px" >${hotelName}</div>
                                <div class="hotel-description" style="display: inline-block">${hotelInfo}</div>
                            </div>
                        `;

                        }
                        hotelsContainer.appendChild(hotelElement);
                    });
                }
            } else {
                console.warn('未找到酒店列表容器元素');
            }
        } else {
            console.log('当前配置中未找到酒店列表数据');
        }

        showStatus('配置已成功加载并渲染', 'success');
    } catch (error) {
        console.error('渲染配置时发生错误:', error);
        showStatus('渲染配置时发生错误: ' + error.message, 'error');
    }
}

function saveConfig() {
    try {
        // 确保在Chrome扩展环境中
        if (typeof chrome === 'undefined' || !chrome.storage) {
            showStatus('当前不在Chrome扩展环境中，无法保存配置', 'error');
            return;
        }

        // 创建新的配置对象
        const newConfig = {};

        // 收集基本配置字段
        const configFields = [
            'apiKey', 'endpointUrl', 'timeout', 'retryCount',
            'enableNotifications', 'theme', 'debugMode'
        ];

        configFields.forEach(field => {
            const element = document.getElementById(field);
            if (element) {
                // 根据元素类型处理值
                if (element.type === 'checkbox') {
                    newConfig[field] = element.checked;
                } else if (element.type === 'number') {
                    newConfig[field] = element.value ? parseInt(element.value, 10) : 0;
                } else {
                    newConfig[field] = element.value.trim();
                }
            }
        });

        // 收集高级设置（如果有）
        newConfig.advancedSettings = {};
        const advancedFields = document.querySelectorAll('[id^="advanced_"]');
        advancedFields.forEach(element => {
            const key = element.id.replace('advanced_', '');
            if (element.type === 'checkbox') {
                newConfig.advancedSettings[key] = element.checked;
            } else if (element.type === 'number') {
                newConfig.advancedSettings[key] = element.value ? parseFloat(element.value) : 0;
            } else {
                newConfig.advancedSettings[key] = element.value.trim();
            }
        });

        // 保存到Chrome存储
        chrome.storage.local.set({ hotelConfig: newConfig }, () => {
            if (chrome.runtime.lastError) {
                showStatus('保存配置失败: ' + chrome.runtime.lastError.message, 'error');
                return;
            }

            // 更新当前配置
            currentConfig = newConfig;

            // 向background脚本发送消息通知配置已更新
            chrome.runtime.sendMessage({
                action: 'updateHotelConfig',
                config: newConfig
            });

            showStatus('配置保存成功', 'success');
        });
    } catch (error) {
        console.error('保存配置时出错:', error);
        showStatus('保存配置时发生错误: ' + error.message, 'error');
    }
}

function resetConfig() {
    try {
        // 确保在Chrome扩展环境中
        if (typeof chrome === 'undefined' || !chrome.storage) {
            showStatus('当前不在Chrome扩展环境中，无法重置配置', 'error');
            return;
        }

        // 显示重置中的状态
        showStatus('正在重置为默认配置...', 'info');

        // 加载默认配置
        loadDefaultConfig();

        // 保存到Chrome存储
        chrome.storage.local.set({ hotelConfig: currentConfig }, () => {
            if (chrome.runtime.lastError) {
                console.error('重置配置保存失败:', chrome.runtime.lastError);
                showStatus('重置配置保存失败', 'error');
            } else {
                // 记录重置时间
                chrome.storage.local.set({ lastResetTime: new Date().toISOString() });
                showStatus('配置已成功重置为默认值', 'success');
            }
        });
    } catch (error) {
        console.error('重置配置时发生错误:', error);
        showStatus('重置配置时发生错误: ' + error.message, 'error');
    }
}

function exportConfig() {
    try {
        // 确保有配置可以导出
        if (!currentConfig || Object.keys(currentConfig).length === 0) {
            showStatus('没有配置可以导出', 'warning');
            return;
        }

        // 显示导出中的状态
        showStatus('正在导出配置文件...', 'info');

        // 准备导出数据 - 添加元数据
        const exportData = {
            config: currentConfig,
            metadata: {
                exportedAt: new Date().toISOString(),
                source: '酒店配置管理',
                version: '1.0.0'
            }
        };

        // 将配置转换为格式化的JSON字符串
        const jsonString = JSON.stringify(exportData, null, 2);

        // 创建Blob对象
        const blob = new Blob([jsonString], { type: 'application/json' });

        // 创建下载链接
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');

        // 设置文件名 - 使用酒店名称或默认名称
        const hotelName = currentConfig.basic?.name || 'hotel-config';
        // 清理文件名，确保安全
        const safeFileName = hotelName.replace(/[^a-z0-9]/gi, '_').toLowerCase();
        a.download = `hotel-config-${safeFileName}-${new Date().toISOString().split('T')[0]}.json`;
        a.href = url;

        // 模拟点击下载
        document.body.appendChild(a);
        a.click();

        // 清理
        setTimeout(() => {
            document.body.removeChild(a);
            URL.revokeObjectURL(url);
        }, 100);

        showStatus('配置文件导出成功', 'success');
    } catch (error) {
        console.error('导出配置时发生错误:', error);
        showStatus('导出配置时发生错误: ' + error.message, 'error');
    }
}

function importConfig() {
    // 触发文件选择
    document.getElementById('fileInput').click();
}

function handleFileImport(event) {
    try {
        // 获取选择的文件
        const fileList = event.target.files;
        if (!fileList || fileList.length === 0) {
            showStatus('未选择文件', 'warning');
            return;
        }

        const file = fileList[0];

        // 验证文件类型
        if (file.type !== 'application/json' && !file.name.endsWith('.json')) {
            showStatus('请选择有效的JSON配置文件', 'error');
            return;
        }

        // 显示导入中的状态
        showStatus('正在导入配置文件...', 'info');

        // 创建FileReader读取文件内容
        const reader = new FileReader();

        reader.onload = function(e) {
            try {
                // 解析JSON内容
                const fileContent = e.target.result;
                const importData = JSON.parse(fileContent);

                // 提取配置 - 支持直接配置对象或包含config字段的对象
                let newConfig;
                if (importData.config) {
                    // 格式如exportConfig导出的格式
                    newConfig = importData.config;
                } else {
                    // 直接的配置对象
                    newConfig = importData;
                }

                // 验证配置结构
                if (!newConfig || typeof newConfig !== 'object') {
                    throw new Error('配置文件格式无效');
                }

                // 确保在Chrome扩展环境中
                if (typeof chrome !== 'undefined' && chrome.storage) {
                    // 保存到Chrome存储
                    chrome.storage.local.set({ hotelConfig: newConfig }, () => {
                        if (chrome.runtime.lastError) {
                            console.error('导入配置保存失败:', chrome.runtime.lastError);
                            showStatus('导入配置保存失败', 'error');
                        } else {
                            // 更新当前配置
                            currentConfig = newConfig;

                            // 更新页面显示
                            renderConfig();

                            // 记录导入时间
                            chrome.storage.local.set({ lastImportTime: new Date().toISOString() });

                            // 向background脚本发送消息通知配置已更新
                            chrome.runtime.sendMessage({
                                action: 'updateHotelConfig',
                                config: newConfig
                            });

                            showStatus('配置文件导入成功', 'success');
                        }
                    });
                } else {
                    // 非Chrome环境，仅更新内存和页面
                    currentConfig = newConfig;
                    renderConfig();
                    showStatus('配置文件导入成功(仅页面)', 'success');
                }
            } catch (error) {
                console.error('解析配置文件失败:', error);
                showStatus('解析配置文件失败: ' + error.message, 'error');
            }
        };

        reader.onerror = function() {
            showStatus('读取文件失败', 'error');
        };

        // 开始读取文件
        reader.readAsText(file);

        // 清空file input，允许再次选择相同文件
        event.target.value = '';
    } catch (error) {
        console.error('处理文件导入时发生错误:', error);
        showStatus('导入配置时发生错误: ' + error.message, 'error');
    }
}

function showStatus(message, type = 'info') {
    const statusDiv = document.getElementById('status');
    if (!statusDiv) return;

    // 设置消息内容
    statusDiv.textContent = message;

    // 根据类型设置样式
    statusDiv.className = 'status'; // 重置类名
    statusDiv.classList.add(type); // 添加类型类名

    // 设置不同类型的样式
    statusDiv.style.backgroundColor = type === 'error' ? '#ffdddd' :
                                     type === 'success' ? '#ddffdd' :
                                     '#ddddff';
    statusDiv.style.color = type === 'error' ? '#d8000c' :
                           type === 'success' ? '#4f8a10' :
                           '#00529b';
    statusDiv.style.padding = '10px';
    statusDiv.style.marginTop = '10px';
    statusDiv.style.marginBottom = '10px';
    statusDiv.style.borderRadius = '4px';
    statusDiv.style.border = '1px solid #ddd';
    statusDiv.style.position = 'fixed'; // 固定定位
    statusDiv.style.top = '0'; // 显示在顶部
    statusDiv.style.left = '50%'; // 水平居中
    statusDiv.style.transform = 'translateX(-50%)'; // 居中偏移
    statusDiv.style.zIndex = '9999'; // 确保在最上层
    statusDiv.style.display = 'block';
    statusDiv.style.minWidth = '300px'; // 最小宽度
    statusDiv.style.textAlign = 'center'; // 文字居中
    statusDiv.style.boxShadow = '0 2px 10px rgba(0,0,0,0.1)'; // 添加阴影

    // 3秒后自动隐藏
    setTimeout(() => {
        statusDiv.style.display = 'none';
    }, 3000);
}

// 添加新配置项功能
function addNewItem() {
    try {
        // 获取输入值
        const hotelName = document.getElementById('newHotelName').value.trim();
        const template = document.getElementById('newTemplate').value.trim();

        // 验证输入
        if (!hotelName) {
            showStatus('请输入酒店名称', 'warning');
            return;
        }

        // 确保currentConfig存在且为对象
        if (!currentConfig || typeof currentConfig !== 'object') {
            currentConfig = {};
        }

        // 确保我们直接在根级别添加酒店配置（与DEFAULT_HOTEL_CONFIG结构一致）
        // 不使用嵌套的advancedSettings或其他对象结构
        currentConfig[hotelName] = template || '';

        // 确保在Chrome扩展环境中
        if (typeof chrome !== 'undefined' && chrome.storage) {
            // 保存到Chrome存储
            chrome.storage.local.set({ hotelConfig: currentConfig }, () => {
                if (chrome.runtime.lastError) {
                    console.error('保存配置失败:', chrome.runtime.lastError);
                    showStatus('保存配置失败', 'error');
                    return;
                }

                // 向background脚本发送消息通知配置已更新
                chrome.runtime.sendMessage({
                    action: 'updateHotelConfig',
                    config: currentConfig
                });

                // 重新渲染配置
                renderConfig();

                // 清空输入框
                document.getElementById('newHotelName').value = '';
                document.getElementById('newTemplate').value = '';

                showStatus(`成功添加新配置: ${hotelName}`, 'success');
            });
            if(Object.keys(currentConfig).length > 0){
                syncToGitee().then(r => {
                    showStatus("同步成功",'success')
                });
            }
        } else {
            // 非Chrome环境，仅更新内存和页面
            renderConfig();
            document.getElementById('newHotelName').value = '';
            document.getElementById('newTemplate').value = '';
            showStatus(`成功添加新配置: ${hotelName} (仅页面)`, 'success');
        }
    } catch (error) {
        console.error('添加新配置时发生错误:', error);
        showStatus('添加新配置失败: ' + error.message, 'error');
    }
}

// 测试Gitee连接功能
  async function testGiteeConnection() {
    try {
        // 确保在Chrome扩展环境中
        if (typeof chrome === 'undefined' || !chrome.runtime) {
            showStatus('当前不在Chrome扩展环境中，无法测试连接', 'error');
            return;
        }

        // 显示测试中的状态
        showStatus('正在测试Gitee连接...', 'info');

        // 向background脚本发送测试连接请求
        const response = await new Promise((resolve, reject) => {
            chrome.runtime.sendMessage({ action: 'testGiteeConnection' }, (response) => {
                if (chrome.runtime.lastError) {
                    reject(new Error(chrome.runtime.lastError.message));
                } else {
                    resolve(response);
                }
            });
        });

        // 处理响应结果
        if (response && response.success) {
            showStatus('Gitee连接测试成功！', 'success');

            // 如果有额外信息，可以显示
            if (response.info) {
                console.log('Gitee连接信息:', response.info);
            }
        } else {
            const errorMessage = response?.error || '连接测试失败';
            showStatus(`Gitee连接测试失败: ${errorMessage}`, 'error');
            console.error('Gitee连接测试失败:', response?.error);
        }
    } catch (error) {
        console.error('测试Gitee连接时发生错误:', error);
        showStatus('测试连接过程中发生错误: ' + error.message, 'error');
    }
}



async function syncToGitee() {
    try {
        // 确保在Chrome扩展环境中
        if (typeof chrome === 'undefined' || !chrome.runtime) {
            showStatus('当前不在Chrome扩展环境中，无法同步到Gitee', 'error');
            return;
        }

        // 显示同步中的状态
        showStatus('正在同步配置到Gitee...', 'info');

        // 向background脚本发送同步请求
        const response = await new Promise((resolve, reject) => {
            chrome.runtime.sendMessage({ action: 'syncToGitee', config: currentConfig }, (response) => {
                if (chrome.runtime.lastError) {
                    reject(new Error(chrome.runtime.lastError.message));
                } else {
                    resolve(response);
                }
            });
        });

        // 处理响应结果
        if (response && response.success) {
            showStatus('配置成功同步到Gitee', 'success');

            // 记录同步时间
            chrome.storage.local.set({ lastSyncTime: new Date().toISOString() });
        } else {
            showStatus('同步到Gitee失败: ' + (response?.error || '未知错误'), 'error');
            console.error('Gitee同步失败:', response?.error);
        }
    } catch (error) {
        console.error('同步到Gitee时发生错误:', error);
        showStatus('同步过程中发生错误: ' + error.message, 'error');
    }
}

async function fetchFromGitee() {
    try {
        // 确保在Chrome扩展环境中
        // if (typeof chrome === 'undefined' || !chrome.runtime) {
        //     showStatus('当前不在Chrome扩展环境中，无法从Gitee获取配置', 'error');
        //     return;
        // }

        // 显示获取中的状态
        showStatus('正在从Gitee获取配置...', 'info');

        // 向background脚本发送获取请求
        const response = await new Promise((resolve, reject) => {
            chrome.runtime.sendMessage({ action: 'fetchFromGitee' }, (response) => {
                if (chrome.runtime.lastError) {
                    reject(new Error(chrome.runtime.lastError.message));
                } else {
                    resolve(response);
                }
            });
        });

        // 处理响应结果
        if (response && response.success && response.config) {
            // 调试日志：打印获取到的配置数据结构
            console.log('从Gitee获取的配置数据:', response.config);
            console.log('配置数据类型:', typeof response.config);

            // 检查是否存在酒店相关数据
            if (Array.isArray(response.config.hotels)) {
                console.log('找到hotels数组，长度:', response.config.hotels.length);
            } else if (Array.isArray(response.config.items)) {
                console.log('找到items数组，长度:', response.config.items.length);
            } else if (Array.isArray(response.config.hotelList)) {
                console.log('找到hotelList数组，长度:', response.config.hotelList.length);
            } else {
                console.log('未找到明显的酒店列表数组，配置的顶级键:', Object.keys(response.config));
            }

            // 更新当前配置
            currentConfig = response.config;

            // 保存到Chrome存储
            chrome.storage.local.set({ hotelConfig: currentConfig }, () => {
                if (chrome.runtime.lastError) {
                    console.error('保存获取的配置失败:', chrome.runtime.lastError);
                }
            });

            // 更新页面显示
            renderConfig();

            // 记录最后获取时间
            chrome.storage.local.set({ lastFetchTime: new Date().toISOString() });

            showStatus('成功从Gitee获取配置', 'success');
        } else {
            showStatus('从Gitee获取配置失败: ' + (response?.error || '未知错误'), 'error');
            console.error('从Gitee获取配置失败:', response?.error);
        }
    } catch (error) {
        console.error('从Gitee获取配置时发生错误:', error);
        showStatus('获取过程中发生错误: ' + error.message, 'error');
    }
}
